package cn.tedu.person.service.impl;

import cn.tedu.person.ex.ServiceException;
import cn.tedu.person.mapper.StaffMapper;
import cn.tedu.person.pojo.dto.StaffInsertDTO;
import cn.tedu.person.pojo.dto.StaffUpdateDTO;
import cn.tedu.person.pojo.entity.Staff;
import cn.tedu.person.pojo.vo.StaffIndexVO;
import cn.tedu.person.pojo.vo.StaffStandardVO;
import cn.tedu.person.service.IStaffService;
import cn.tedu.person.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Slf4j
@Service
public class StaffImpl implements IStaffService {

    @Autowired
    private StaffMapper staffMapper;

    @Override
    public void addNew(StaffInsertDTO staffInsertDTO) {
        log.info("开始处理添加的业务 {}",staffInsertDTO);
        //判断身份证号有没有重复的
        String numberId=staffInsertDTO.getNumberId();
        int count=staffMapper.countByNumberId(numberId);
        if(count>0){
            String message = "添加员工失败，身份证号已经被占用！";
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        //下面的操作是判断depth

        //通过对象获取到到leaderId
        Long leaderId= staffInsertDTO.getLeaderId();
        System.out.println("leaderId="+leaderId);
        StaffStandardVO leaderStaff=null;
        //先给深度假设一个数字
        Integer depth=0;
        Integer rankId=0;
        //判断leaderId是否为0 如果是0 则没有领导 如果不是0
        //TODO 可以添加管理层的功能还没实现
        // 则为普通员工 此项目添加员工只添加普通员工
        if(leaderId !=0) {
            //leader!=0
            leaderStaff= staffMapper.getStandardById(leaderId);
            System.out.println("leaderStaff="+leaderStaff);
            //判断查询领导级别是否为NULL（有没有领导这个人）
            if(leaderStaff == null){
                //如果为NULL 则抛出异常
                String message="添加员工失败，领导级别不存在";
                log.info(message);
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
            }else{
                //如果不为NULL 则depth=父级的depth+1-----
                System.out.println("depth="+depth);
                int ls=leaderStaff.getDepth();
                System.out.println("ls="+ls);
                depth=leaderStaff.getDepth()+1;
                System.out.println("depth="+depth);
            }
        }

        //下面的操作是添加员工
        Staff staff=new Staff();
        BeanUtils.copyProperties(staffInsertDTO,staff);
        System.out.println("staffInsertDTO="+staffInsertDTO);
        staff.setDepth(depth);
        staff.setRankId(rankId);
//        staff.setTime(new Data());
        System.out.println("staff="+staff);
        int rows=staffMapper.insert(staff);
        System.out.println("rows="+rows);
        if (rows != 1) {
            String message = "添加员工失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UNKNOWN, message);
        }

        //下面的操作是确定领导的身份是否为领导 有下属，领导的身份rankID=1
        //判断leaderId是否不为0 并且领导级别的rankId是否为0
        //如果是 则将领导级类别的rankId更新为1
        if(leaderId != 0 && leaderStaff.getRankId() == 0){
            Staff updateLeaderStaff=new Staff();
            updateLeaderStaff.setLeaderId(leaderId);
            updateLeaderStaff.setRankId(1);
            rows = staffMapper.update(updateLeaderStaff);
            System.out.println("rows="+rows);
            if (rows != 1) {
                String message = "添加员工失败，服务器忙，请稍后再尝试！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_UNKNOWN, message);
            }
        }
    }

    @Override
    public void delete(Long id) {
        log.debug("开始处理【根据ID删除类别】的业务，参数：{}", id);
        //当前查出来的对象
        StaffStandardVO currentStaff = staffMapper.getStandardById(id);
        if(currentStaff == null){
            String message = "删除员工失败，尝试删除的员工数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        //判断是否为领导级 领导级别的不能直接删除(有子集的不能删)
        if(currentStaff.getRankId() == 1){
            String message = "删除员工失败，该员工下仍包含子级类别！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        //进行删除操作
        int rows = staffMapper.deleteById(id);
        if (rows != 1) {
            String message = "删除人员失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_DELETE, message);
        }
        //员工系统中，管理层就是管理层，不管有没有下属员工 所以当删除员工后，
        // TODO ---后续实现  需要对他的领导做出depth的修改
    }

    @Override
    public void setLeader(Long id) {
        log.debug("开始处理【管理层】的业务，参数：{}", id);
        updateRankId(id, 1);
    }

    @Override
    public void setNoLeader(Long id) {
        log.debug("开始处理【普通员工】的业务，参数：{}", id);
        updateRankId(id, 0);
    }

    //处理员工身份 1 管理层 0 普通员工
    private void updateRankId(Long id, Integer rankId) {
        StaffStandardVO queryResult= staffMapper.getStandardById(id);
        if(queryResult == null){
            String message = "调整员工身份为"+RANK_TEXT[rankId]+"身份失败！员工信息不存在";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        //判断员工的身份是否与参数的rankId是否相同，如果相同，则异常
        if(queryResult.getRankId() == rankId){
            String message = "此员工已经处于"+RANK_TEXT[rankId]+"身份！不可修改！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        Staff updateStaff=new Staff();
        updateStaff.setId(id);
        updateStaff.setRankId(rankId);

        int rows=staffMapper.update(updateStaff);
        if(rows !=1 ){
            String message = "调整员工身份为"+RANK_TEXT[rankId]+"身份失败！服务器忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public List<StaffStandardVO> listByLeaderId(Long leaderId) {
        log.debug("开始处理【根据父级类别查询子级类别列表】的" +
                "业务，参数：{}", leaderId);
        List<StaffStandardVO> list= staffMapper.listByLeaderId(leaderId);
        return list;
    }

    @Override
    public void updateInfoById(Long id, StaffUpdateDTO staffUpdateDTO) {
        log.debug("开始处理【修改类别详情】的业务，ID：{}，新数据：{}",
                id, staffUpdateDTO);

        StaffStandardVO queryResult= staffMapper.getStandardById(id);
        if(queryResult == null){
            String message = "查询员工详情失败，员工信息不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        int count= staffMapper.countByNumberIdAndNotId(
                id,staffUpdateDTO.getNumberId());
        if(count>0){
            String message = "修改员工详情失败，此身份证号已存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        Staff staff=new Staff();
        BeanUtils.copyProperties(staffUpdateDTO,staff);
        staff.setId(id);
        int rows=staffMapper.update(staff);
        if(rows !=1 ){
            String message = "修改员工详情失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public StaffStandardVO getStandardById(Long id) {
        StaffStandardVO queryResult= staffMapper.getStandardById(id);
        if(queryResult == null){
            String message = "查询员工详情失败，员工信息不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        return queryResult;
    }
}
